identidad = np.array(
  [[0, 0, 0, 
    0, 1, 0, 
    0, 0, 0]])

desenfoque = (1/9) * np.array(
  [[1, 1, 1,
    1, 1, 1,
    1, 1, 1]])

enfoque = np.array(
  [[0, -1, 0,
    -1, 5, -1,
    0, -1, 0]])

emboss = np.array(
  [[-2, -1,  0,
    -1,  1,  1,
    0,  1,  2]])

kernels = [identidad, desenfoque, enfoque, emboss]
kernel_name = ["identidad", "desenfoque", "enfoque", "emboss"]

figure, axis = plt.subplots(2, 2, figsize = (12, 10))
for kernel, name, ax in zip(kernels, kernel_name, axis.flatten()):
  img_convolusion = cv2.filter2D(img, -1, kernel)
  ax.imshow(abs(img_convolusion), cmap = "gray")
  ax.set_title(name)

plt.show()

fig, ax = plt.subplots(8, 8, figsize=(6, 6), dpi=100)
for i, axi in enumerate(ax.flat):
    no_imprimir = axi.imshow(x_train[i], cmap='binary', vmin=0, vmax=255)
    no_imprimir = axi.set(xticks=[], yticks=[])
plt.show()

fig, ax = plt.subplots(8, 8, figsize=(6, 6), dpi=100)
for i, axi in enumerate(ax.flat):
    no_imprimir = axi.imshow(x_test[i], cmap='binary', vmin=0, vmax=255)
    no_imprimir = axi.set(xticks=[], yticks=[])
plt.show()

# Calculamos la cantidad de etiquetas
num_labels = len(np.unique(y_train))

# Convertimos a l forma one-hot vector
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

# Dimensiones de entrada de la imagen
image_size = x_train.shape[1]

# Cambiar el tamaño
x_train = np.reshape(x_train,[-1, image_size, image_size, 1])
x_test = np.reshape(x_test,[-1, image_size, image_size, 1])
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255

#-----Parámetros por utilizar----
# La imagen es procesada en escala de grices
input_shape = (image_size, image_size, 1)
kernel_size = 3
pool_size = 2
filters = 64
dropout = 0.2

model = Sequential()

model.add(Conv2D(filters=filters,
                 kernel_size=kernel_size,
                 activation='relu',
                 input_shape=input_shape))
model.add(MaxPooling2D(pool_size))

model.add(Conv2D(filters=filters,
                 kernel_size=kernel_size,
                 activation='relu'))
model.add(MaxPooling2D(pool_size))

model.add(Conv2D(filters=filters,
                 kernel_size=kernel_size,
                 activation='relu'))

#Aplanamos los datos
model.add(Flatten())

# dropout added as regularizer
model.add(Dropout(dropout))

#Hidden layers
model.add(Dense(40, activation = "relu"))
model.add(Dense(20, activation = "sigmoid"))

# La capa de salida deve ser 10-dim one-hot vector
model.add(Dense(num_labels))
model.add(Activation('softmax'))

# Resumen de la estructura
model.summary()

#Función para graficar un grafo con la estructura de la red neuronal
# Requiere graphviz y pydot
#plot_model(model, to_file='cnn-mnist.png', show_shapes=True)
#img = mpimg.imread('cnn-mnist.png')
#plt.imshow(img)
#plt.show()

# Función de costo para one-hot vector
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

# Entrenamos el modelo
batch_size = 128

model.fit(x_train, y_train, epochs=10, batch_size=batch_size, verbose = 0)

salida, acc = model.evaluate(x_test,
                             y_test,
                             batch_size=batch_size,
                             verbose=0)

print("\nPrecisión Global: %.1f%%" % (100.0 * acc))

# carga el  mnist dataset
train, (x_test, y_test) = mnist.load_data()

#Estos datos son los que puede procesar el modelo
x_test_model = np.reshape(x_test,[-1, 28, 28, 1])
x_test_model = x_test_model.astype('float32') / 255

print(x_test_model.shape)

#Graficamos los números que vamos a intentar clasificar

fig, ax = plt.subplots(4, 4, figsize=(6, 6), dpi=100)
for i, axi in enumerate(ax.flat):
    no_imprimir = axi.imshow(x_test[i], cmap = 'gray', vmin=0, vmax=255)
    no_imprimir = axi.set(xticks=[], yticks=[])
plt.show()

#Predecimos 16 imágenes
pred = model.predict(x_test_model[0:16])

#Para obtener las "etiquetas"

pred = np.argmax(pred, axis = -1)

#Mostramos las predicciones
print("Predicciones en fila: ",pred,"\n")

print("Predicciones 4x4:\n", np.reshape(pred,[4,4]))

labels = []
imagenes = []

for carpeta in next(os.walk('datos/climas/'))[1]:
  for nombrearchivo in next(os.walk('datos/climas/' + '/' + carpeta))[2]:
    if re.search("\\.(jpg|jpeg|png|bmp|tiff)$", nombrearchivo):
      try:
        img = cv2.imread('datos/climas/' + '/' + carpeta + '/' + nombrearchivo)[...,::-1]
        img = cv2.resize(img, (64, 64))
        imagenes.append(img)
        labels.append(carpeta)
      except:
        print("No se pudo cargar la imagen: " + nombrearchivo + " en la carpeta: " + carpeta)

X = np.array(imagenes, dtype = np.float32)
y = np.array(labels)

print(
  'Total de individuos: ', len(X),
  '\nNúmero total de salidas: ', len(np.unique(y)), 
  '\nClases de salida: ', np.unique(y))

# Dividir en train y test
train_X, test_X, train_Y, test_Y = train_test_split(X, y, test_size = 0.05)

# Normalizar
train_X = train_X / 255.
test_X  = test_X / 255.

# Cambiamos las etiquetas de categoricas a one-hot encoding
train_Y_one_hot = pd.get_dummies(train_Y)
train_Y_one_hot = train_Y_one_hot.to_numpy()

test_Y_one_hot = pd.get_dummies(test_Y)
test_Y_one_hot = test_Y_one_hot.to_numpy()

train_Y_one_hot

epochs = 50
batch_size = 64
 
modelo_clima = Sequential()

modelo_clima.add(Conv2D(64, kernel_size=(3, 3),
                       activation='linear',padding='same',input_shape=(64,64,3)))
modelo_clima.add(LeakyReLU(alpha=0.1))
modelo_clima.add(MaxPooling2D((2, 2),padding='same'))
modelo_clima.add(Dropout(0.5))
 
modelo_clima.add(Flatten())
modelo_clima.add(Dense(32, activation='linear'))
modelo_clima.add(LeakyReLU(alpha=0.1))
modelo_clima.add(Dropout(0.5))

modelo_clima.add(Dense(len(np.unique(y)), activation='softmax'))
 
modelo_clima.summary()

INIT_LR = 1e-3
modelo_clima.compile(loss=keras.losses.categorical_crossentropy, 
                    optimizer=keras.optimizers.Adagrad(lr=INIT_LR),
                    metrics=['accuracy'])

#Entrenamos el modelo
modelo_clima.fit(train_X, train_Y_one_hot, batch_size = batch_size,
                epochs = epochs, verbose = 0)
    
# Guardamos la red, para reutilizarla en el futuro, sin tener que volver a entrenar

modelo_clima.save("cnn_clima.h5py")

from tensorflow.keras.models import load_model
modelo_clima = load_model('cnn_clima.h5py')

#Evaluamos con respecto a la tabla de testing
test_eval = modelo_clima.evaluate(test_X, test_Y_one_hot, verbose=0)
 
print('\nTest loss:', test_eval[0])

print('Test accuracy:', test_eval[1])

from urllib.request import Request, urlopen

req = Request('https://images.pexels.com/photos/1870259/pexels-photo-1870259.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500', headers={'User-Agent': 'Mozilla/5.0'})
response = urlopen(req)
arr = np.asarray(bytearray(response.read()), dtype=np.uint8)
img_1 = cv2.imdecode(arr, -1)[...,::-1]

req = Request('https://parquesalegres.org/wp-content/uploads/2018/06/lluvia-4-1023x767.jpg', headers={'User-Agent': 'Mozilla/5.0'})
response = urlopen(req)
arr = np.asarray(bytearray(response.read()), dtype=np.uint8)
img_2 = cv2.imdecode(arr, -1)[...,::-1]

req = Request('https://www.surfertoday.com/images/jamp/page/sunrisesunsettime.jpg', headers={'User-Agent': 'Mozilla/5.0'})
response = urlopen(req)
arr = np.asarray(bytearray(response.read()), dtype=np.uint8)
img_3 = cv2.imdecode(arr, -1)[...,::-1]

req = Request('https://us.123rf.com/450wm/candy18/candy181801/candy18180100138/94577205-panorama-de-asfalto-de-carreteras-en-el-campo-en-un-d%C3%ADa-soleado-de-primavera-ruta-en-el-bello-paisaj.jpg?ver=6', headers={'User-Agent': 'Mozilla/5.0'})
response = urlopen(req)
arr = np.asarray(bytearray(response.read()), dtype=np.uint8)
img_4 = cv2.imdecode(arr, -1)[...,::-1]

imgs = np.array([img_1, img_2, img_3, img_4])

fig, ax = plt.subplots(1, 4, figsize=(6, 6), dpi=100)
for i, axi in enumerate(ax.flat):
    axi.imshow(imgs[i])
    axi.set(xticks=[], yticks=[])

plt.show()

# Preparamos lo datos como los requiere el modelo
imgs = np.array([cv2.resize(img_1, (64, 64)), cv2.resize(img_2, (64, 64)), cv2.resize(img_3, (64, 64)), cv2.resize(img_4, (64, 64))])
imgs = imgs.astype('float32')
imgs = imgs / 255.

pred = modelo_clima.predict(imgs)

print("\nPredicciones: ", np.argmax(pred, axis = 1))

print("\nPredicciones: ", np.unique(y)[np.argmax(pred, axis = 1)])